// 游戏状态变量
let canvas, ctx;
let playerPlane = { x: 0, y: 0 };
let playerScreenY = 0;
let enemies = [];
let bullets = [];
let offsetY = 0;
let gameState = { gameOver: false };
let animationId = null;
let gameActive = false; // 游戏是否激活状态
let isPaused = false; // 游戏是否暂停状态

// 游戏常量
const moveSpeed = 1;
const cellSize = 20;
const gap = 2;
const squareSize = cellSize + gap;
const bulletSpeed = 5;

// 按键状态
const keys = {
  w: false,
  a: false,
  s: false,
  d: false,
  j: false
};

// 按键冷却时间（毫秒）
const KEY_COOLDOWN = 150; // 每150毫秒允许一次移动
let lastKeyTime = {
  w: 0,
  a: 0,
  s: 0,
  d: 0,
  j: 0
};

// 初始化游戏
function initGame() {
  // 修复1：先停止现有游戏循环
  stopGame();
  
  // 获取页面元素
  canvas = document.getElementById('planeCanvas');
  ctx = canvas.getContext('2d');
  
  resizeCanvas();
  // 初始化玩家飞机位置在屏幕底部中央
  const cols = Math.floor(canvas.width / squareSize);
  playerPlane.x = Math.floor(cols / 2) - 1;
  playerScreenY = canvas.height - squareSize * 3;
  playerPlane.y = Math.floor((playerScreenY - offsetY) / squareSize);
  bullets = [];
  
  // 修复2：重置偏移量！！！
  offsetY = 0; // 关键修复：重置背景位置
  
  // 修复3：避免重复绑定事件
  if (!window.__planeGameEventsBound) {
    setupKeyboardControls();
    window.__planeGameEventsBound = true;
  }
  
  animate();
}

// 激活游戏（开始生成敌机）
function _activateGameImpl() {
  gameActive = true;
  // 初始化一些敌机
  for (let i = 0; i < 5; i++) {
    generateEnemy();
  }
}

// 停用游戏（停止生成敌机）
function _deactivateGameImpl() {
  gameActive = false;
  // 清空所有敌机
  enemies = [];
}

function stopGame() {
  // 修复5：确保能取消所有动画帧
  if (animationId) {
    cancelAnimationFrame(animationId);
    animationId = null;
  }
}

// 暂停游戏
function pauseGame() {
  isPaused = true;
  if (animationId) {
    cancelAnimationFrame(animationId);
    animationId = null;
  }
}

// 恢复游戏
function resumeGame() {
  isPaused = false;
  if (!animationId) {
    animate();
  } else {
    // 强制重新启动动画循环
    cancelAnimationFrame(animationId);
    animate();
  }
}

// 设置键盘控制
function setupKeyboardControls() {
  // 处理调整画布大小事件
  window.removeEventListener('resize', resizeCanvas);
  window.addEventListener('resize', resizeCanvas);
    // 确保只添加一次事件监听器
  if (!window.__planeKeydownHandler) {
    window.__planeKeydownHandler = handleKeyDown;
    window.addEventListener('keydown', window.__planeKeydownHandler);
  }

  // 添加键盘释放事件监听
  if (!window.__planeKeyupHandler) {
    window.__planeKeyupHandler = handleKeyUp;
    window.addEventListener('keyup', window.__planeKeyupHandler);
  }

  // 添加键盘事件监听
  function handleKeyDown(e) {
      // 游戏结束状态下，只响应回车键
      if (gameState.gameOver) {
        if (e.key.toLowerCase() === 'enter') {
          restartGame();
          e.preventDefault();
        }
        return;
      }

      // 非游戏结束状态下，处理其他按键
      switch(e.key.toLowerCase()) {
        case 'w':
          keys.w = true;
          e.preventDefault();
          break;
        case 's':
          keys.s = true;
          e.preventDefault();
          break;
        case 'a':
          keys.a = true;
          e.preventDefault();
          break;
        case 'd':
          keys.d = true;
          e.preventDefault();
          break;
        case 'j':
          keys.j = true;
          e.preventDefault();
          break;
        case 'p':
          if (isPaused) {
            resumeGame();
          } else {
            pauseGame();
          }
          e.preventDefault();
          break;
      }
  }
}
// 添加按键释放事件处理
function handleKeyUp(e) {
    switch(e.key.toLowerCase()) {
      case 'w':
        keys.w = false;
        e.preventDefault();
        break;
      case 's':
        keys.s = false;
        e.preventDefault();
        break;
      case 'a':
        keys.a = false;
        e.preventDefault();
        break;
      case 'd':
        keys.d = false;
        e.preventDefault();
        break;
      case 'j':
        keys.j = false;
        e.preventDefault();
        break;
    }
}
// 清理键盘事件监听
function cleanupKeyboardControls() {
  if (window.__planeKeydownHandler) {
    window.removeEventListener('keydown', window.__planeKeydownHandler);
    window.__planeKeydownHandler = null;
  }
  if (window.__planeKeyupHandler) {
    window.removeEventListener('keyup', window.__planeKeyupHandler);
    window.__planeKeyupHandler = null;
  }
}

// 生成敌机
function generateEnemy() {
  if (!gameActive) return; // 只有在游戏激活时才生成敌机
  
  // 在屏幕顶部随机位置生成敌机（与可视区域最顶层对齐）
  const col = Math.floor(Math.random() * Math.floor(canvas.width / squareSize));
  // 计算可视区域最顶层的网格坐标
  const topRow = Math.floor(-offsetY / squareSize);
  const enemy = {
    x: col,
    y: topRow
  };
  enemies.push(enemy);
}

// 发射子弹
function fireBullet() {
  // 子弹从玩家飞机中心位置发射
  const bullet = {
    x: playerPlane.x, // 飞机中心x坐标（世界坐标）
    y: playerPlane.y,     // 飞机顶部y坐标（世界坐标）
    worldY: playerPlane.y * squareSize + offsetY // 世界像素坐标y值
  };
  bullets.push(bullet);
}

// 检测碰撞
function checkCollision(playerX, playerY, enemyX, enemyY) {
  // 玩家飞机的四个方块位置（世界坐标）
  const playerBlocks = [
    { x: playerX + 1, y: playerY },     // 顶部
    { x: playerX, y: playerY + 1 },     // 左侧
    { x: playerX + 1, y: playerY + 1 }, // 中间
    { x: playerX + 2, y: playerY + 1 }  // 右侧
  ];
  
  // 敌机位置（世界坐标）- 修正：敌机实际位置是 enemyX + 1
  const enemyBlock = { x: enemyX + 1, y: enemyY + 1 };
  
  // 检查敌机是否与玩家飞机的任何一个方块碰撞
  for (let block of playerBlocks) {
    if (block.x === enemyBlock.x && block.y === enemyBlock.y) {
      return true;
    }
  }
  
  return false;
}

// 检测子弹与敌机碰撞
function checkBulletEnemyCollision(bulletX, bulletY, enemyX, enemyY) {
  // 子弹位置（世界坐标）
  const bulletBlock = { x: bulletX, y: bulletY };
  
  // 敌机位置（世界坐标）- 敌机实际位置是 enemyX + 1, enemyY + 1
  const enemyBlock = { x: enemyX, y: enemyY };
  
  // 检查子弹是否与敌机碰撞
  return bulletBlock.x === enemyBlock.x && bulletBlock.y === enemyBlock.y;
}

// 绘制飞机（玩家飞机）
function drawPlayerPlane(x, y) {
  ctx.fillStyle = 'rgba(255, 255, 255, 0.8)'; // 浅白色

  // 顶部
  ctx.fillRect(x + squareSize, y, cellSize, cellSize);
  
  // 左侧
  ctx.fillRect(x, y + squareSize, cellSize, cellSize);
  
  // 中间
  ctx.fillRect(x + squareSize, y + squareSize, cellSize, cellSize);
  
  // 右侧
  ctx.fillRect(x + squareSize * 2, y + squareSize, cellSize, cellSize);
}

// 绘制敌机
function drawEnemyPlane(x, y) {
  ctx.fillStyle = 'rgba(255, 0, 0, 0.8)'; 

  ctx.fillRect(x + squareSize, y + squareSize, cellSize, cellSize);
}

// 绘制子弹
function drawBullet(x, y) {
  ctx.fillStyle = 'rgba(255, 255, 255, 0.9)'; // 浅白色
  // 子弹绘制在中心位置
  ctx.fillRect(x + squareSize, y, cellSize, cellSize);
}

// 绘制游戏结束画面
function drawPauseOverlay() {
  ctx.fillStyle = 'rgba(0, 0, 0, 0.7)';
  ctx.fillRect(0, 0, canvas.width, canvas.height);
  
  ctx.fillStyle = 'white';
  ctx.font = '48px Arial';
  ctx.textAlign = 'center';
  ctx.fillText('游戏暂停', canvas.width / 2, canvas.height / 2 - 50);
  
  ctx.font = '24px Arial';
  ctx.fillText('按 P 键继续游戏', canvas.width / 2, canvas.height / 2 + 20);
}

function drawGameOver() {
  ctx.fillStyle = 'rgba(0, 0, 0, 0.8)';
  ctx.fillRect(0, 0, canvas.width, canvas.height);
  
  ctx.fillStyle = 'white';
  ctx.font = '48px Arial';
  ctx.textAlign = 'center';
  ctx.fillText('游戏结束', canvas.width / 2, canvas.height / 2 - 50);
  
  ctx.font = '24px Arial';
  ctx.fillText('按回车键重新开始', canvas.width / 2, canvas.height / 2 + 20);
}

// 绘制游戏画面
function drawGame() {
  ctx.fillStyle = '#272626';
  ctx.fillRect(0, 0, canvas.width, canvas.height);

  const alpha = 0.05;
  const startRow = Math.floor(-offsetY / squareSize);
  const endRow = Math.floor((canvas.height - offsetY) / squareSize);
  const cols = Math.floor(canvas.width / squareSize);

  ctx.fillStyle = `rgba(240, 240, 220, ${alpha})`;
  for (let y = startRow; y <= endRow; y++) {
    for (let x = 0; x < cols; x++) {
      const worldY = y * squareSize;
      const viewY = worldY + offsetY;
      ctx.fillRect(x * squareSize, viewY, cellSize, cellSize);
    }
  }

  // 绘制玩家飞机（使用世界坐标，跟随背景网格移动）
  const playerX = playerPlane.x * squareSize;
  const playerY = playerPlane.y * squareSize + offsetY;
  drawPlayerPlane(playerX, playerY);

  // 绘制敌机 (红色)
  for (let enemy of enemies) {
    // 将网格坐标转换为视口坐标
    const enemyX = enemy.x * squareSize;
    const enemyY = enemy.y * squareSize + offsetY;
    drawEnemyPlane(enemyX, enemyY);
  }
  
  // 绘制子弹 (浅白色)
  for (let bullet of bullets) {
    const bulletX = bullet.x * squareSize;
    const bulletY = bullet.worldY;
    drawBullet(bulletX, bulletY);
  }
  
  // 如果游戏结束，绘制游戏结束画面
  if (gameState.gameOver) {
    drawGameOver();
  } else if (isPaused) {
    drawPauseOverlay();
  }
}

// 重新开始游戏
function restartGame() {
  gameState.gameOver = false;
  isPaused = false; // 重置暂停状态
  enemies = [];
  bullets = [];
  offsetY = 0; // 确保重置背景偏移
  keys.w = keys.a = keys.s = keys.d = keys.j = false; // 重置按键状态
  
  initGame();
  if (gameActive) {
    _activateGameImpl();
  }
}

// 更新游戏状态
function updateGame() {
  if (gameState.gameOver || isPaused) {
    return; // 游戏结束或暂停时停止更新
  }
  
  offsetY += moveSpeed;
  
  // 自动调整玩家飞机的世界坐标y值，以保持屏幕视觉位置不变
  playerPlane.y = Math.floor((playerScreenY - offsetY) / squareSize);
  
  // 更新玩家位置（通过改变屏幕视觉位置来控制飞机）
  const cols = Math.floor(canvas.width / squareSize);
  
  // 获取当前时间
  const currentTime = Date.now();
  
  // W键：向前移动一格（屏幕位置向上）
  if (keys.w && playerScreenY > 0) {
    if (currentTime - lastKeyTime.w > KEY_COOLDOWN) {
      playerScreenY -= squareSize;
      lastKeyTime.w = currentTime;
    }
  }
  
  // A键：向左移动一格
  if (keys.a && playerPlane.x > 0) {
    if (currentTime - lastKeyTime.a > KEY_COOLDOWN) {
      playerPlane.x -= 1;
      lastKeyTime.a = currentTime;
    }
  }
  
  // S键：向后移动一格（屏幕位置向下）
  if (keys.s && playerScreenY < canvas.height - squareSize * 3) {
    if (currentTime - lastKeyTime.s > KEY_COOLDOWN) {
      playerScreenY += squareSize;
      lastKeyTime.s = currentTime;
    }
  }
  
  // D键：向右移动一格
  if (keys.d && playerPlane.x < cols - 3) {
    if (currentTime - lastKeyTime.d > KEY_COOLDOWN) {
      playerPlane.x += 1;
      lastKeyTime.d = currentTime;
    }
  }
  
  // J键：发射子弹
  if (keys.j) {
    if (currentTime - lastKeyTime.j > KEY_COOLDOWN) {
      fireBullet();
      lastKeyTime.j = currentTime;
    }
  }
  
  // 更新子弹位置
  for (let i = bullets.length - 1; i >= 0; i--) {
    bullets[i].worldY -= bulletSpeed;
    
    // 移除超出屏幕的子弹
    if (bullets[i].worldY < -squareSize) {
      bullets.splice(i, 1);
      continue;
    }
    
    // 更新子弹的世界坐标y值
    bullets[i].y = Math.floor((bullets[i].worldY - offsetY) / squareSize);
  }
  
  // 移动敌机并检测碰撞
  for (let i = enemies.length - 1; i >= 0; i--) {
    // 检测玩家与敌机碰撞
    if (checkCollision(playerPlane.x, playerPlane.y, enemies[i].x, enemies[i].y)) {
      gameState.gameOver = true;
      isPaused = false; // 游戏结束时重置暂停状态
      return;
    }
    
    // 检测子弹与敌机碰撞
    let enemyHit = false;
    for (let j = bullets.length - 1; j >= 0; j--) {
      // 使用子弹的世界坐标进行碰撞检测
      if (checkBulletEnemyCollision(bullets[j].x, bullets[j].y, enemies[i].x, enemies[i].y)) {
        // 移除子弹和敌机
        bullets.splice(j, 1);
        enemies.splice(i, 1);
        enemyHit = true;
        break;
      }
    }
    
    if (enemyHit) continue;
    
    // 移除移出屏幕的敌机
    if (enemies[i].y * squareSize + offsetY > canvas.height) {
      enemies.splice(i, 1);
    }
  }
  
  // 随机生成新敌机（只有在游戏激活时才生成）
  if (gameActive && Math.random() < 0.03) {
    generateEnemy();
  }
}

// 动画循环
function animate() {
  updateGame();
  drawGame();
  animationId = requestAnimationFrame(animate);
}

// 调整画布大小
function resizeCanvas() {
  if (canvas) {
    canvas.width = window.innerWidth;
    canvas.height = window.innerHeight;
  }
}

// 导出游戏控制函数和键盘状态对象
export default {
  startGame: initGame,
  activateGame: _activateGameImpl,
  deactivateGame: _deactivateGameImpl,
  endGame: stopGame,
  pauseGame,
  resumeGame,
  restartGame,
  keys,
  gameState,
  cleanupKeyboardControls,
  get isPaused() {
    return isPaused;
  }
};